Please address the comments from this code review:

## Individual Comments

### Comment 1
<location path="astrbot/core/provider/func_tool_manager.py" line_range="675-684" />
<code_context>
+        connect_done = asyncio.Event()
+        connect_error: BaseException | None = None
+
+        async def connect_and_lifecycle() -> None:
+            #Single task that handles connect, lifecycle, and cleanup.
+
+            nonlocal connect_error
+            try:
+                await mcp_client.connect_to_server(cfg, name)
+                await mcp_client.list_tools_and_save()
+            except asyncio.CancelledError:
+                # cleanup on cancellation
+                try:
+                    await mcp_client.cleanup()
+                except BaseException:
+                    pass
+                raise
+            except Exception as e:
+                connect_error = e
+                try:
+                    await mcp_client.cleanup()
+                except Exception:
+                    pass
+                connect_done.set()
+                return
+
+            # Register tools
+            self.func_list = [
+                f
</code_context>
<issue_to_address>
**issue (bug_risk):** Tool registration and logging errors won’t propagate via connect_error, leaving the caller to see only a timeout.

Because the `try` ends at `await mcp_client.list_tools_and_save()`, any exception during tool registration or logging won’t set `connect_error` or `connect_done`. The caller will then hit the timeout and raise `MCPInitTimeoutError` instead of the real failure. Please extend the `try` to include the registration/logging block, or add a dedicated `try/except` there that sets `connect_error` and signals `connect_done` on error.
</issue_to_address>

Please address the comments from this code review:

## Individual Comments

### Comment 1
<location path="astrbot/core/provider/func_tool_manager.py" line_range="672" />
<code_context>
+        mcp_client = MCPClient()
+        mcp_client.name = name
+
+        connect_done = asyncio.Event()
+        connect_error: BaseException | None = None
+
</code_context>
<issue_to_address>
**issue (complexity):** Consider replacing the `connect_done`/`connect_error` pattern with a single connect `Future` and centralized cleanup to simplify the MCP client startup lifecycle and error handling.

The main added complexity comes from `connect_done` + `connect_error` plus duplicated cleanup inside `connect_and_lifecycle`. You can keep the “single task owns anyio contexts and cleanup” behavior while simplifying the handshake and reusing the existing cleanup helper.

### 1. Replace `connect_done` / `connect_error` with a single `Future`

Use a single `Future` to signal completion/failure of the connect phase, instead of an `Event` + shared exception variable:

```python
mcp_client = MCPClient()
mcp_client.name = name

loop = asyncio.get_running_loop()
connect_future: asyncio.Future[None] = loop.create_future()

async def connect_and_lifecycle() -> None:
    try:
        await mcp_client.connect_to_server(cfg, name)
        await mcp_client.list_tools_and_save()
    except asyncio.CancelledError as e:
        # Ensure connect_future is completed
        if not connect_future.done():
            connect_future.set_exception(e)
        try:
            await self._cleanup_mcp_client_safely(mcp_client, name)
        except BaseException:
            pass
        raise
    except Exception as e:
        if not connect_future.done():
            connect_future.set_exception(e)
        try:
            await self._cleanup_mcp_client_safely(mcp_client, name)
        except BaseException:
            pass
        return

    # Register tools (same as current behavior)
    self.func_list = [
        f
        for f in self.func_list
        if not (isinstance(f, MCPTool) and f.mcp_server_name == name)
    ]
    for tool in mcp_client.tools:
        func_tool = MCPTool(
            mcp_tool=tool,
            mcp_client=mcp_client,
            mcp_server_name=name,
        )
        self.func_list.append(func_tool)

    logger.info(
        f"Connected to MCP server {name}, "
        f"Tools: {[t.name for t in mcp_client.tools]}"
    )

    # Signal successful connect
    if not connect_future.done():
        connect_future.set_result(None)

    try:
        await shutdown_event.wait()
        logger.info(f"Received shutdown signal for MCP client {name}")
    except asyncio.CancelledError:
        logger.debug(f"MCP client {name} task was cancelled")
        raise
    finally:
        await asyncio.shield(self._terminate_mcp_client(name))
```

Then the outer timeout / error handling becomes simpler and more idiomatic:

```python
lifecycle_task = asyncio.create_task(
    connect_and_lifecycle(), name=f"mcp-client:{name}"
)

async with self._runtime_lock:
    self._mcp_server_runtime[name] = _MCPServerRuntime(
        name=name,
        client=mcp_client,
        shutdown_event=shutdown_event,
        lifecycle_task=lifecycle_task,
    )
    self._mcp_starting.discard(name)

try:
    await asyncio.wait_for(connect_future, timeout=timeout)
except asyncio.TimeoutError as exc:
    lifecycle_task.cancel()
    await asyncio.gather(lifecycle_task, return_exceptions=True)
    async with self._runtime_lock:
        self._mcp_starting.discard(name)
        self._mcp_server_runtime.pop(name, None)
    raise MCPInitTimeoutError(
        f"Connected to MCP server {name} timeout ({timeout:g} seconds)"
    ) from exc
except asyncio.CancelledError:
    lifecycle_task.cancel()
    await asyncio.gather(lifecycle_task, return_exceptions=True)
    async with self._runtime_lock:
        self._mcp_starting.discard(name)
        self._mcp_server_runtime.pop(name, None)
    raise
except Exception:
    lifecycle_task.cancel()
    await asyncio.gather(lifecycle_task, return_exceptions=True)
    async with self._runtime_lock:
        self._mcp_starting.discard(name)
        self._mcp_server_runtime.pop(name, None)
    raise
```

This keeps:

- A single task owning connection, tool registration, shutdown wait, and `_terminate_mcp_client`.
- Precise timeout on the connect phase.
- Centralized cleanup via `_cleanup_mcp_client_safely` and `_terminate_mcp_client`.

But removes the manual `connect_done` signaling and `connect_error` shared state, making the control flow and error propagation easier to reason about.
</issue_to_address>